home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / PASCAL / ALLSWAGS.ZIP / SWAGN-R.ZIP / NETWORK.SWG / 0040_Netware 3.11 API Library - NetMsg.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1996-11-29  |  11.0 KB  |  419 lines
  1. {
  2.             ╔══════════════════════════════════════════════════╗
  3.             ║     ┌╦═══╦┐┌╦═══╦┐┌╦═══╦┐┌╦═╗ ╦┐┌╦═══╦┐┌╔═╦═╗┐   ║
  4.             ║     │╠═══╩┘├╬═══╬┤└╩═══╦┐│║ ║ ║│├╬══      ║      ║
  5.             ║     └╩     └╩   ╩┘└╩═══╩┘└╩ ╚═╩┘└╩═══╩┘   ╩      ║
  6.             ║                                                  ║
  7.             ║     NetWare 3.11 API Library for Turbo Pascal    ║
  8.             ║                      by                          ║
  9.             ║                 S.Perevoznik                     ║
  10.             ║                     1996                         ║
  11.             ╚══════════════════════════════════════════════════╝
  12. }
  13.  
  14. Unit NetMsg;
  15.  
  16. Interface
  17.  
  18. Const
  19.   AllMessage        = 0;  { receive all message                   }
  20.   ServerOnly        = 1;  { receive message from file server only }
  21.   NoMessage         = 2;  { not receive messag                    }
  22.   StoreMessage      = 3;  { store message                         }
  23.   DisableCheckTimer = 5;  { disable check shell timer             }
  24.   EnableCheckTimer  = 6;  { enable check shell timer              }
  25.  
  26.  
  27. Procedure SetBroadcastMode(Mode: byte);
  28.  
  29. Procedure SendToCon(Msg:String);
  30. {send message to console }
  31.  
  32. Procedure DisableMSG;
  33. { disable broadcast message}
  34.  
  35. Procedure EnableMSG;
  36. { enable broadcast message }
  37.  
  38. Function  GetBroadcastMode : byte;
  39. { return current broadcast mode }
  40.  
  41. Function  SendBroadcastMessage(Message:string;
  42.                                ConnectionNumber:byte) : byte;
  43. { send broadcast message to station with
  44.   connection number}
  45.  
  46. Function  GetBroadcastMessage : String;
  47.  
  48. Function LogNetWorkMessage(msg : string) : byte;
  49. {}
  50.  
  51. Function OpenMessagePipe(ConnectionList  : string;
  52.                          Var ResultList  : string;
  53.                          ConnectionCount : byte) : byte;
  54.  
  55. Function CloseMessagePipe(ConnectionList : string;
  56.                          Var ResultList  : string;
  57.                          ConnectionCount : byte) : byte;
  58.  
  59. Function CheckPipeStatus (ConnectionList  : string;
  60.                           Var ResultList  : string;
  61.                           ConnectionCount : byte) : byte;
  62.  
  63. Function  SendPersonalMessage(Message:string;
  64.                                ConnectionNumber:byte) : byte;
  65.  
  66. Function  GetPersonalMessage (Var ConnectionNumber : byte): String;
  67.  
  68.  
  69.  
  70. Implementation
  71.  
  72. Uses Dos;
  73.  
  74.  
  75. Procedure SetBroadcastMode(Mode : byte);
  76.  var
  77.     r : registers;
  78.  begin
  79.     r.BX := r.DS;
  80.     r.AH := $0DE;
  81.     r.DL := MODE;
  82.     intr($21,r);
  83.     r.DS := r.BX;
  84.  end;
  85.  
  86. Function GetBroadcastMode : byte;
  87.  var
  88.    r : registers;
  89.  begin
  90.    r.AH := $0DE;
  91.    r.DL := 4;
  92.    Intr($21,r);
  93.    GetBroadcastMode := r.AL;
  94.  end;
  95.  
  96. Procedure DisableMSG;
  97.  var
  98.    r : registers;
  99.    SendPacket  : array[0..4] of byte;
  100.    ReplyPacket : array[0..3] of byte;
  101.    WordPtr     : ^word;
  102.  begin
  103.   SendPacket[2] := 2;
  104.   WordPtr  := addr(SendPacket);
  105.   WordPtr^ := 1;
  106.   WordPtr  := addr(ReplyPacket);
  107.   WordPtr^ := 2;
  108.   r.BX := r.DS;
  109.   r.AH := $0E1;
  110.   r.DS := SEG(SendPacket);
  111.   r.SI := OFS(SendPacket);
  112.   r.ES := SEG(ReplyPacket);
  113.   r.DI := OFS(ReplyPacket);
  114.   intr($21,r);
  115.   r.DS := r.BX;
  116.  end;
  117.  
  118.  
  119. Procedure EnableMSG;
  120.  var
  121.    r : registers;
  122.    SendPacket  : array[0..4] of byte;
  123.    ReplyPacket : array[0..3] of byte;
  124.    WordPtr     : ^word;
  125. begin
  126.   SendPacket[2] := 3;
  127.   WordPtr  := addr(SendPacket);
  128.   WordPtr^ := 1;
  129.   WordPtr  := addr(ReplyPacket);
  130.   WordPtr^ := 2;
  131.   r.BX := r.DS;
  132.   r.AH := $0E1;
  133.   r.DS := SEG(SendPacket);
  134.   r.SI := OFS(SendPacket);
  135.   r.ES := SEG(ReplyPacket);
  136.   r.DI := OFS(ReplyPacket);
  137.   intr($21,r);
  138.   r.DS := r.BX;
  139. end;
  140.  
  141. Function SendBroadcastMessage(Message:string; ConnectionNumber:byte) : byte;
  142.   var
  143.     WordPtr     : ^word;
  144.     SendPacket  : array [0..160] of byte;
  145.     ReplyPacket : array [0..103] of byte;
  146.  
  147.     r  : registers;
  148.  
  149.   begin
  150.    SendPacket[2] := 0;
  151.    SendPacket[3] := 1;
  152.    SendPacket[4] := ConnectionNumber;
  153.    SendPacket[5] := length(Message);
  154.    if SendPacket[5] > 56 then SendPacket[5] := 56;
  155.    move(Message[1],SendPacket[6],length(Message));
  156.    WordPtr  := addr(SendPacket);
  157.    WordPtr^ := Length(Message) + 4;
  158.    WordPtr  := addr(ReplyPacket);
  159.    WordPtr^ := 2;
  160.    ReplyPacket[2] := 1;
  161.    ReplyPacket[3] := 0;
  162.    ReplyPacket[4] := 0;
  163.      r.AH := $E1;
  164.      r.BX := r.DS;
  165.      r.DS := SEG(SendPacket);
  166.      r.SI := OFS(SendPacket);
  167.      r.ES := SEG(ReplyPacket);
  168.      r.DI := OFS(ReplyPacket);
  169.      Intr($21,r);
  170.      r.DS := r.BX;
  171.      SendBroadcastMessage := r.AL;
  172.  end;
  173.  
  174. Procedure SendToCon(Msg : string);
  175. var
  176.   s   : array [0..64] of byte;
  177.   i   : integer;
  178.   r   : registers;
  179. begin
  180.  
  181.   s[0] := 0;
  182.   s[1] := 4;
  183.   s[2] := $09;
  184.   s[3] := length(Msg);
  185.   if S[3] > 60 then S[3] := 60;
  186.   move(Msg[1],s[4],length(Msg));
  187.   r.AH := $0E1;
  188.   r.BX := r.DS;
  189.   r.DS := SEG(S);
  190.   r.SI := OFS(S);
  191.   Intr($21,r);
  192.   r.DS := r.BX;
  193. end;
  194.  
  195. Function LogNetWorkMessage(msg : string) : byte;
  196.   var
  197.     SendPacket  : array[0..84] of byte;
  198.     ReplyPacket : array[0..2] of byte;
  199.     r : registers;
  200.     WordPtr     : ^word;
  201.  
  202. begin
  203.     SendPacket[2] := $0D;
  204.     SendPacket[3] := Length(Msg);
  205.     if Length(Msg) > 80 then SendPacket[3] := 80;
  206.     move(Msg[1],SendPacket[4],SendPacket[3]);
  207.     WordPtr  := addr(SendPacket);
  208.     WordPtr^ := SendPacket[3] + 2;
  209.     WordPtr  := addr(ReplyPacket);
  210.     WordPtr^ := 0;
  211.      r.AL := 0;
  212.      r.AH := $E3;
  213.      r.BX := r.DS;
  214.      r.DS := SEG(SendPacket);
  215.      r.SI := OFS(SendPacket);
  216.      r.ES := SEG(ReplyPacket);
  217.      r.DI := OFS(ReplyPacket);
  218.      Intr($21,r);
  219.      r.DS := r.BX;
  220.      LogNetWorkMessage := r.AL;
  221. end;
  222.  
  223. Function  GetBroadcastMessage : String;
  224.   var
  225.     r: registers;
  226.     SendPacket  : array [0..3] of byte;
  227.     ReplyPacket : array [0..58] of byte;
  228.     WordPtr     : ^word;
  229.     Len         : byte;
  230.     St          : string;
  231.  
  232.   begin
  233.     WordPtr  := addr(SendPacket);
  234.     WordPtr^ := 1;
  235.     SendPacket[2] := 1;
  236.     WordPtr  := addr(ReplyPacket);
  237.     WordPtr^ := 56;
  238.     ReplyPacket[2] := 55;
  239.      r.AH := $E1;
  240.      r.BX := r.DS;
  241.      r.DS := SEG(SendPacket);
  242.      r.SI := OFS(SendPacket);
  243.      r.ES := SEG(ReplyPacket);
  244.      r.DI := OFS(ReplyPacket);
  245.      Intr($21,r);
  246.      r.DS := r.BX;
  247.      if r.AL = 0 then
  248.       begin
  249.         Len := ReplyPacket[2];
  250.         move(ReplyPacket[3], st[1], Len);
  251.         move(Len,st[0],1);
  252.         GetBroadcastMessage := st;
  253.       end;
  254.     end;
  255.  
  256. Function OpenMessagePipe(ConnectionList  : string;
  257.                          Var ResultList  : string;
  258.                          ConnectionCount : byte) : byte;
  259. { æ«ºñá¡¿Ñ ¬á¡á½á «í¼Ñ¡á ß««íΘÑ¡¿∩¼¿ }
  260. var
  261.     r: registers;
  262.     SendPacket  : array [0..104] of byte;
  263.     ReplyPacket : array [0..103] of byte;
  264.     WordPtr     : ^word;
  265.  
  266. begin
  267.    SendPacket[2] := 6;
  268.    SendPacket[3] := ConnectionCount;
  269.    move(ConnectionList[1],SendPacket[4],ConnectionCount);
  270.    WordPtr  := addr(SendPacket);
  271.    WordPtr^ := ConnectionCount + 2;
  272.    WordPtr  := addr(ReplyPacket);
  273.    WordPtr^ := ConnectionCount + 1;
  274.      r.AH := $E1;
  275.      r.BX := r.DS;
  276.      r.DS := SEG(SendPacket);
  277.      r.SI := OFS(SendPacket);
  278.      r.ES := SEG(ReplyPacket);
  279.      r.DI := OFS(ReplyPacket);
  280.      Intr($21,r);
  281.      r.DS := r.BX;
  282.      if r.AL = 0 then
  283.       move(ReplyPacket[3],ResultList[1],ConnectionCount);
  284.       OpenMessagePipe := r.AL;
  285. end;
  286.  
  287.  
  288. Function CloseMessagePipe(ConnectionList : string;
  289.                          Var ResultList  : string;
  290.                          ConnectionCount : byte) : byte;
  291. { çá¬αδΓ¿Ñ ¬á¡á½á «í¼Ñ¡á ß««íΘÑ¡¿∩¼¿ }
  292. var
  293.     r: registers;
  294.     SendPacket  : array [0..104] of byte;
  295.     ReplyPacket : array [0..103] of byte;
  296.     WordPtr     : ^word;
  297. begin
  298.    SendPacket[2] := 7;
  299.    SendPacket[3] := ConnectionCount;
  300.    move(ConnectionList[1],SendPacket[4],ConnectionCount);
  301.    WordPtr  := addr(SendPacket);
  302.    WordPtr^ := ConnectionCount + 2;
  303.    WordPtr  := addr(ReplyPacket);
  304.    WordPtr^ := ConnectionCount + 1;
  305.    ReplyPacket[2] := ConnectionCount;
  306.      r.AH := $E1;
  307.      r.BX := r.DS;
  308.      r.DS := SEG(SendPacket);
  309.      r.SI := OFS(SendPacket);
  310.      r.ES := SEG(ReplyPacket);
  311.      r.DI := OFS(ReplyPacket);
  312.      Intr($21,r);
  313.      r.DS := r.BX;
  314.      if r.AL = 0 then
  315.       move(ReplyPacket[3],ResultList[1],ConnectionCount);
  316.       CloseMessagePipe := r.AL;
  317.  
  318. end;
  319.  
  320. Function CheckPipeStatus (ConnectionList  : string;
  321.                           Var ResultList  : string;
  322.                           ConnectionCount : byte) : byte;
  323. { Åα«óÑα¬á ß«ßΓ«∩¡¿∩ ¬á¡á½á «í¼Ñ¡á ß««íΘÑ¡¿∩¼¿ }
  324. var
  325.     r: registers;
  326.     SendPacket  : array [0..104] of byte;
  327.     ReplyPacket : array [0..103] of byte;
  328.     WordPtr     : ^word;
  329. begin
  330.    SendPacket[2] := 8;
  331.    SendPacket[3] := ConnectionCount;
  332.    move(ConnectionList[1],SendPacket[4],ConnectionCount);
  333.    WordPtr  := addr(SendPacket);
  334.    WordPtr^ := ConnectionCount + 2;
  335.    WordPtr  := addr(ReplyPacket);
  336.    WordPtr^ := ConnectionCount + 1;
  337.    ReplyPacket[2] := ConnectionCount;
  338.      r.AH := $E1;
  339.      r.BX := r.DS;
  340.      r.DS := SEG(SendPacket);
  341.      r.SI := OFS(SendPacket);
  342.      r.ES := SEG(ReplyPacket);
  343.      r.DI := OFS(ReplyPacket);
  344.      Intr($21,r);
  345.      r.DS := r.BX;
  346.      if r.AL = 0 then
  347.       move(ReplyPacket[3],ResultList[1],ConnectionCount);
  348.       CheckPipeStatus := r.AL;
  349.  
  350. end;
  351.  
  352. Function SendPersonalMessage(Message:string; ConnectionNumber:byte) : byte;
  353.   var
  354.     WordPtr     : ^word;
  355.     SendPacket  : array [0..231] of byte;
  356.     ReplyPacket : array [0..103] of byte;
  357.     r  : registers;
  358.  
  359.   begin
  360.    SendPacket[2] := 4;
  361.    SendPacket[3] := 1;
  362.    SendPacket[4] := ConnectionNumber;
  363.    SendPacket[5] := length(Message);
  364.    if SendPacket[5] > 126 then SendPacket[5] := 126;
  365.    move(Message[1],SendPacket[6],length(Message));
  366.    WordPtr  := addr(SendPacket);
  367.    WordPtr^ := Length(Message) + 4;
  368.    WordPtr  := addr(ReplyPacket);
  369.    WordPtr^ := 2;
  370.    ReplyPacket[2] := 1;
  371.    ReplyPacket[3] := 0;
  372.    ReplyPacket[4] := 0;
  373.      r.AH := $E1;
  374.      r.BX := r.DS;
  375.      r.DS := SEG(SendPacket);
  376.      r.SI := OFS(SendPacket);
  377.      r.ES := SEG(ReplyPacket);
  378.      r.DI := OFS(ReplyPacket);
  379.      Intr($21,r);
  380.      r.DS := r.BX;
  381.      SendPersonalMessage := r.AL;
  382.  end;
  383.  
  384. Function  GetPersonalMessage(Var ConnectionNumber: byte) : String;
  385.   var
  386.     r: registers;
  387.     SendPacket  : array [0..3] of byte;
  388.     ReplyPacket : array [0..132] of byte;
  389.     WordPtr     : ^word;
  390.     Len         : byte;
  391.     St          : string;
  392.  
  393.   begin
  394.     WordPtr  := addr(SendPacket);
  395.     WordPtr^ := 1;
  396.     SendPacket[2] := 5;
  397.     WordPtr  := addr(ReplyPacket);
  398.     WordPtr^ := 130;
  399.      r.AH := $E1;
  400.      r.BX := r.DS;
  401.      r.DS := SEG(SendPacket);
  402.      r.SI := OFS(SendPacket);
  403.      r.ES := SEG(ReplyPacket);
  404.      r.DI := OFS(ReplyPacket);
  405.      Intr($21,r);
  406.      r.DS := r.BX;
  407.      if r.AL = 0 then
  408.       begin
  409.         Len := ReplyPacket[3];
  410.         move(ReplyPacket[4], st[1], Len);
  411.         move(Len,st[0],1);
  412.         GetPersonalMessage := st;
  413.       end
  414.     else GetPersonalMessage := '';
  415.     ConnectionNumber := ReplyPacket[2];
  416.     end;
  417.  
  418. end.
  419.